package org.upo.eps.it.phama.dao;

import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.upo.eps.it.phama.bean.PedidoCliente;
import org.upo.eps.it.phama.bean.Producto;
import org.upo.eps.it.phama.bean.Proveedor;
import org.upo.eps.it.phama.util.HibernateUtil;

/**
 *
 * @author grupo 4
 */
public class ProductoDAO {

    /**
     * Obtiene el objeto persistente cuyo id corresponde con el aportado como
     * parámetro.
     *
     * @param idPedido Integer con el número de pedido que se interesa.
     * @return Objeto de la clase Producto.
     */
    public static Producto getById(Integer idProducto) {
        Producto resultado;

        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();        
        resultado = (Producto) session.get(Producto.class, idProducto);
        session.close();

        return resultado;
    }

    /**
     * Obtiene una lista con todos los productos existentes en la base de datos.
     *
     * @return Lista de objetos de la clase Producto.
     */
    public static List<Producto> getProductos() {
        List<Producto> productos;
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        String sql = "from Producto";
        Query qry = session.createQuery(sql);
        productos = (List<Producto>) qry.list();
        session.close();

        return productos;
    }

    /**
     * Efectúa la búsqueda de todos aquéllos productos cuyos atributos
     * correspondan con todos los parámetros recibidos. Si no se aporta algún
     * parámetro, el mismo será sustituido por el comodín que implica a todos.
     * Como la cadena de búsqueda se construye a base de comparadores
     * <code>like</code>, los parámetros pueden contender el comodín
     * <code>%</code>.
     *
     * @param nombre String con el nombre del producto que se busca.
     * @param coste String con el precio de compra al proveedor del producto.
     * @param precio String con el precio de venta a los clientes del producto.
     * @return Lista de objetos de la clase Producto que cumplen con los
     * parámetros aportados.
     */
    public static List<Producto> search(String nombre, String coste, String precio, String almacen, String proveedor) {
        List<Producto> resultado;
        /* Si algún parámetro no tuviera contenido, se sustituye por el comodín %, que indica que se ese campo NO se tendrá
         * en cuenta en la búsqueda.
         */
        String n = nombre.trim().isEmpty() ? "%" : nombre.trim();
        String c = coste.trim().isEmpty() ? "%" : coste.trim();
        String p = precio.trim().isEmpty() ? "%" : precio.trim();
        String a = almacen.trim().isEmpty() ? "%" : almacen.trim();
        String pr = proveedor.trim().isEmpty() ? "%" : proveedor.trim();
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();

        /* Finalmente, se construye la cadena sql a base de comparadores like y de comparadores = en el caso del precio y del coste
         * y se ejecuta la consulta.
         */
        String sql = "from Producto where nombre like '" + n + "' ";

        if (c.equals("%")) {
            sql += "and coste like '" + c + "' ";
        } else {
            sql += "and coste = " + c + " ";
        }

        if (p.equals("%")) {
            sql += "and precio like '" + p + "'";
        } else {
            sql += "and precio = " + p;
        }

        if (a.equals("%")) {
            sql += "and almacen.idAlmacen like '" + a + "'";
        } else {
            sql += "and almacen.idAlmacen = " + a;
        }

        if (pr.equals("%")) {
            sql += "and proveedor.idProveedor like '" + pr + "'";
        } else {
            sql += "and proveedor.idProveedor = " + pr;
        }
        Query qry = session.createQuery(sql);
        resultado = (List<Producto>) qry.list();
        session.close();

        return resultado;
    }

    /**
     * Se hace persistente el producto recibido como parámetro.
     *
     * @param producto Objeto de la clase Producto.
     * @throws HibernateException
     */
    public static void save(Producto producto) throws HibernateException {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        try {
            // Se guarda el producto en la base de datos.
            session.saveOrUpdate(producto);
            session.getTransaction().commit();
        } catch (HibernateException ex) {
            session.getTransaction().rollback();
            throw ex;
        }
    }

    /**
     * Se persisten los cambios efectuados en el objeto recibido como parámetro.
     *
     * @param producto Objeto de la clase Producto cuyos cambios se quieren
     * guardar.
     */
    public static void update(Producto producto) {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        try {
            session.merge(producto);
            session.flush();
            session.getTransaction().commit();
        } catch (HibernateException ex) {
            session.getTransaction().rollback();
            throw ex;
        }
    }

    /**
     * Se elimina de la base de datos el producto cuyo id se recibe como
     * parámetro.
     *
     * @param id Integer con el id del producto que se quiere eliminar.
     * @throws HibernateException
     */
    public static void delete(int id) throws HibernateException {
        Session session = HibernateUtil.getSessionFactory().getCurrentSession();
        session.beginTransaction();
        try {
            Query qry = session.createQuery(String.format("delete Producto where idProducto = %d", id));
            qry.executeUpdate();
            session.getTransaction().commit();
        } catch (HibernateException ex) {
            session.getTransaction().rollback();
            throw ex;
        }
    }
}
